home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Highlands / Highlands Huge.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  52.2 KB  |  1,582 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Highlands Huge.rmv
  4. //
  5. //
  6. // Highlands definitions for large maps.
  7. //
  8. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  9. // PROPRIETARY and CONFIDENTIAL.
  10. //
  11. // $Author: Scott Marison $
  12. // $Date: 9/06/01 6:46p $
  13. // $Revision: 26 $
  14. // $Revision: 26 $
  15. //   Adjusted Angle between team members 
  16. // $Revision:
  17. //  Revision: 13 Lowered elevation, added neutrals, pushed players outward,
  18. //               lowered player outer radius, increased tree %, reduced
  19. //               forest free radius, reduced resource to edge distance
  20. //
  21. //  Revision: 14 Used Highlands Small as the foundation.  Increased Neutral
  22. //               islands and percent land
  23. //  Revision: 15 revised for miniaturization
  24. //  Revision: 16 Elevation 
  25. //  Revision: 17 Revised # of resources 3 by 3
  26. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  27. //  Revision: 19 General Adjustments
  28. //  Revision: 20c Small Enhancements 
  29. //  Revision: 21 Design Enhancements
  30. //  Revision: 23 Reduced Resources
  31. //  Revision: 24 Added Chance of steep cliffs 
  32. //  Revision: 25 Two forage sites for Prehistoric Start 
  33. //  Revision: 26 Evened-out resource distribution 
  34. //  Revision: 26b Created neutral berry bushes for Prehistoric starts 
  35. //  Revision: 26h Increased ally/resource distance 
  36. //  Revision: 28 Moved resources 2 tiles further from Capitol
  37. //  Revision: 29 Added gold and iron to 5+ player maps
  38. //
  39. //
  40. //////////////////////////////////////////////////////////////////////
  41.  
  42. #if            NOTDEFINED(HIGHLANDS_HUGE_RMV)
  43. #define        (HIGHLANDS_HUGE_RMV,1)
  44.  
  45. //////////////////////////////////////////////////////////////////////
  46. // Definitions we are required to define for highlands maps
  47. //////////////////////////////////////////////////////////////////////
  48.  
  49. ResourcePlacementLimit (Gold,     8,    15)
  50. ResourcePlacementLimit (Steel,     8,     15)
  51. ResourcePlacementLimit (Stone,     8,     15)
  52. ResourcePlacementLimit (Berry,     7,     12)
  53. ResourcePlacementLimit (Fish,     1,    50)
  54. ResourcePlacementLimit (Tree,     3,     6)
  55. ResourcePlacementLimit (Animal,     7,     15)
  56.  
  57. #if Is2Players
  58. //////////////////////////////////////////////////////////////////////
  59. // 2 PLAYERS...
  60. //////////////////////////////////////////////////////////////////////
  61.  
  62. ResourceSeperation    5 
  63.  
  64. //////////////////////////////////////////////////////////////////////
  65. // terrain definitions
  66. #if        PERCENT(80)
  67.   #define        (kMaxIntElevation,            10)
  68. #else
  69.   #define        (kMaxIntElevation,            16)
  70. #endif
  71.  
  72. #define        (kElevationScale,                Between(1, 1))
  73. #define        (kHeightMapChaos,                Between(40, 50))
  74.                                             
  75. #define        (kMinimumStartPositionToMapEdge    5)
  76. #define        (kOuterPushFromMapCenter        25)
  77. #define        (kInnerPushFromMapCenter         0)    
  78.     
  79. #define        (kConvergentSampleSize,            3) 
  80. #define        (kConvergentThreshold,            20000)        
  81.  
  82. //////////////////////////////////////////////////////////////////////
  83. // player definitions
  84. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  85. #define        (kPlayerInnerRadius,            0.6)
  86. #define        (kPlayerOuterRadius,            0.95)
  87. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  88. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  89. #define        (kPlayerLandChaos,            0.8)
  90. #define        (kPlayerLandClumps,            Between(1, 1))
  91. #define        (kPlayerFlatChaos,            0.8)
  92. #define        (kPlayerFlatClumps,            Between(1, 1))
  93. #define        (kPlayerTreePercentage,            0.07)
  94.  
  95.  
  96. //////////////////////////////////////////////////////////////////////
  97. // inner neutral definitions
  98. #define        (kNeutralInnerRadius,            0.2)
  99. #define        (kNeutralOuterRadius,            0.5)
  100. #define        (kNeutralOptimalFactor,            0.7)
  101. #define        (kNumInnerNeutrals,                 Between(18, 18))
  102. #define        (kInnerNeutralPercentLand,        0.25)
  103. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  104. #define        (kInnerNeutralTreePercentage,          0.2)
  105. #define        (kInnerNeutralLandChaos,        0.8)
  106. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  107. #define        (kInnerNeutralFlatChaos,        0.8)
  108. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  109.  
  110.  
  111. //////////////////////////////////////////////////////////////////////
  112. // outer neutral definitions
  113. #define        (kNumOuterNeutrals,            Between(46, 46))
  114. #define        (kOuterNeutralPercentLand,        0.70)
  115. #define        (kOuterNeutralPercentFlat,        0.9)
  116. #define        (kOuterNeutralTreePercentage,          0.15)
  117. #define        (kOuterNeutralLandChaos,        0.8)
  118. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  119. #define        (kOuterNeutralFlatChaos,        0.8)
  120. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  121.  
  122.  
  123. //////////////////////////////////////////////////////////////////////
  124. // resource definitions
  125. #define        (kMaxResourceElevation,            3)
  126. #define        (kResourceToEdgeDistance,        2)
  127. #define        (kResourceToWaterDistance,        3)
  128.  
  129. #define        (kAnimalPerPlayer,            0)
  130. #define        (kAnimalPerNeutral,            0)
  131.  
  132. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  133.   #define  (kBerryPerPlayer,    1) 
  134.   #define  (kBerryPerNeutral,      6)
  135. #else
  136.   #define  (kBerryPerPlayer,    1)
  137.   #define  (kBerryPerNeutral,      0)
  138. #endif 
  139.  
  140. #define        (kFishPerPlayer,                0)
  141. #define        (kFishPerNeutral,                0)
  142.  
  143. #define        (kGoldPerPlayer,                1)
  144. #define        (kGoldPerNeutral,                9)
  145.  
  146. #define        (kOilPerPlayer,                0)
  147. #define        (kOilPerNeutral,                0)
  148.  
  149. #define        (kSteelPerPlayer,                1)
  150. #define        (kSteelPerNeutral,            9)
  151.  
  152. #define        (kStonePerPlayer,                1)
  153. #define        (kStonePerNeutral,            3)
  154.  
  155. #define        (kTreePerPlayer,                1)
  156. #define        (kTreePerNeutral,                0)
  157.  
  158.  
  159. //////////////////////////////////////////////////////////////////////
  160. // forest definitions
  161. #define        (kForestFreeRadius,                10.0)
  162. #define        (kForestsPerPlayer,                1)
  163. #define        (kForestChaosLevel,                .01)
  164. #define        (kMaxClumpsPerForest,                  3)
  165.  
  166. #elif Is3Players
  167. //////////////////////////////////////////////////////////////////////
  168. // 3 PLAYERS...
  169. //////////////////////////////////////////////////////////////////////
  170.  
  171. ResourceSeperation    5 
  172.  
  173. //////////////////////////////////////////////////////////////////////
  174. // terrain definitions
  175. #if        PERCENT(80)
  176.   #define        (kMaxIntElevation,            10)
  177. #else
  178.   #define        (kMaxIntElevation,            16)
  179. #endif
  180.  
  181. #define        (kElevationScale,                Between(1, 1))
  182. #define        (kHeightMapChaos,                Between(40, 50))
  183.                                             
  184. #define        (kMinimumStartPositionToMapEdge    5)
  185. #define        (kOuterPushFromMapCenter        25)
  186. #define        (kInnerPushFromMapCenter         0)    
  187.     
  188. #define        (kConvergentSampleSize,            32) 
  189. #define        (kConvergentThreshold,            10)        
  190.                                             
  191. //////////////////////////////////////////////////////////////////////
  192. // player definitions
  193. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  194. #define        (kPlayerInnerRadius,            0.6)
  195. #define        (kPlayerOuterRadius,            0.95)
  196. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  197. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  198. #define        (kPlayerLandChaos,            0.8)
  199. #define        (kPlayerLandClumps,            Between(1, 1))
  200. #define        (kPlayerFlatChaos,            0.8)
  201. #define        (kPlayerFlatClumps,            Between(1, 1))
  202. #define        (kPlayerTreePercentage,            0.07)
  203.  
  204.  
  205. //////////////////////////////////////////////////////////////////////
  206. // inner neutral definitions
  207. #define        (kNeutralInnerRadius,            0.2)
  208. #define        (kNeutralOuterRadius,            0.5)
  209. #define        (kNeutralOptimalFactor,            0.7)
  210. #define        (kNumInnerNeutrals,            Between(18, 18))
  211. #define        (kInnerNeutralPercentLand,        0.25)
  212. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  213. #define        (kInnerNeutralTreePercentage,          0.2)
  214. #define        (kInnerNeutralLandChaos,        0.8)
  215. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  216. #define        (kInnerNeutralFlatChaos,        0.8)
  217. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  218.  
  219. //////////////////////////////////////////////////////////////////////
  220. // outer neutral definitions
  221. #define        (kNumOuterNeutrals,            Between(44, 44))
  222. #define        (kOuterNeutralPercentLand,        0.68)
  223. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  224. #define        (kOuterNeutralTreePercentage,          0.16)
  225. #define        (kOuterNeutralLandChaos,        0.8)
  226. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  227. #define        (kOuterNeutralFlatChaos,        0.8)
  228. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  229.  
  230. //////////////////////////////////////////////////////////////////////
  231. // resource definitions
  232. #define        (kMaxResourceElevation,            3)
  233. #define        (kResourceToEdgeDistance,        2)
  234. #define        (kResourceToWaterDistance,        4)
  235.  
  236. #define        (kAnimalPerPlayer,            0)
  237. #define        (kAnimalPerNeutral,            0)
  238.  
  239. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  240.   #define  (kBerryPerPlayer,    1) 
  241.   #define  (kBerryPerNeutral,      9)
  242. #else
  243.   #define  (kBerryPerPlayer,    1)
  244.   #define  (kBerryPerNeutral,      0)
  245. #endif 
  246.  
  247.  
  248. #define        (kFishPerPlayer,                0)
  249. #define        (kFishPerNeutral,                0)
  250.  
  251. #define        (kGoldPerPlayer,                1)
  252. #define        (kGoldPerNeutral,                12)
  253.  
  254. #define        (kOilPerPlayer,                0)
  255. #define        (kOilPerNeutral,                0)
  256.  
  257. #define        (kSteelPerPlayer,                1)
  258. #define        (kSteelPerNeutral,            12)
  259.  
  260. #define        (kStonePerPlayer,                1)
  261. #define        (kStonePerNeutral,            4)
  262.  
  263. #define        (kTreePerPlayer,                1)
  264. #define        (kTreePerNeutral,                0)
  265.  
  266.  
  267. //////////////////////////////////////////////////////////////////////
  268. // forest definitions
  269. #define        (kForestFreeRadius,                10.0)
  270. #define        (kForestsPerPlayer,                1)
  271. #define        (kForestChaosLevel,                .01)
  272. #define        (kMaxClumpsPerForest,                  3)
  273.  
  274. #elif Is4Players
  275. //////////////////////////////////////////////////////////////////////
  276. // 4 PLAYERS...
  277. //////////////////////////////////////////////////////////////////////
  278.  
  279. ResourceSeperation    5 
  280.  
  281. //////////////////////////////////////////////////////////////////////
  282. // terrain definitions
  283. #if        PERCENT(80)
  284.   #define        (kMaxIntElevation,            10)
  285. #else
  286.   #define        (kMaxIntElevation,            16)
  287. #endif
  288.  
  289. #define        (kElevationScale,                Between(1, 1))
  290. #define        (kHeightMapChaos,                Between(40, 50))
  291.                                             
  292. #define        (kMinimumStartPositionToMapEdge    5)
  293. #define        (kOuterPushFromMapCenter        25)
  294. #define        (kInnerPushFromMapCenter         0)    
  295.     
  296. #define        (kConvergentSampleSize,            32) 
  297. #define        (kConvergentThreshold,            8)
  298.                     
  299. //////////////////////////////////////////////////////////////////////
  300. // player definitions
  301. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  302. #define        (kPlayerInnerRadius,            0.6)
  303. #define        (kPlayerOuterRadius,            0.95)
  304. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  305. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  306. #define        (kPlayerLandChaos,            0.8)
  307. #define        (kPlayerLandClumps,            Between(1, 1))
  308. #define        (kPlayerFlatChaos,            0.8)
  309. #define        (kPlayerFlatClumps,            Between(1, 1))
  310. #define        (kPlayerTreePercentage,            0.07)
  311.  
  312.  
  313. //////////////////////////////////////////////////////////////////////
  314. // inner neutral definitions
  315. #define        (kNeutralInnerRadius,            0.2)
  316. #define        (kNeutralOuterRadius,            0.5)
  317. #define        (kNeutralOptimalFactor,            0.7)
  318. #define        (kNumInnerNeutrals,                 Between(18, 18))
  319. #define        (kInnerNeutralPercentLand,        0.23)
  320. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  321. #define        (kInnerNeutralTreePercentage,          0.25)
  322. #define        (kInnerNeutralLandChaos,        0.8)
  323. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  324. #define        (kInnerNeutralFlatChaos,        0.8)
  325. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  326.  
  327. //////////////////////////////////////////////////////////////////////
  328. // outer neutral definitions
  329. #define        (kNumOuterNeutrals,            Between(42, 42))
  330. #define        (kOuterNeutralPercentLand,        0.67)
  331. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  332. #define        (kOuterNeutralTreePercentage,          0.16)
  333. #define        (kOuterNeutralLandChaos,        0.8)
  334. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  335. #define        (kOuterNeutralFlatChaos,        0.8)
  336. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  337.  
  338. //////////////////////////////////////////////////////////////////////
  339. // resource definitions
  340. #define        (kMaxResourceElevation,            3)
  341. #define        (kResourceToEdgeDistance,        2)
  342. #define        (kResourceToWaterDistance,        4)
  343.  
  344. #define        (kAnimalPerPlayer,            0)
  345. #define        (kAnimalPerNeutral,            0)
  346.  
  347. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  348.   #define  (kBerryPerPlayer,    1) 
  349.   #define  (kBerryPerNeutral,      7)
  350. #else
  351.   #define  (kBerryPerPlayer,    1)
  352.   #define  (kBerryPerNeutral,      0)
  353. #endif 
  354.  
  355.  
  356. #define        (kFishPerPlayer,                0)
  357. #define        (kFishPerNeutral,                0)
  358.  
  359. #define        (kGoldPerPlayer,                1)
  360. #define        (kGoldPerNeutral,                14)
  361.  
  362. #define        (kOilPerPlayer,                0)
  363. #define        (kOilPerNeutral,                0)
  364.  
  365. #define        (kSteelPerPlayer,                1)
  366. #define        (kSteelPerNeutral,            14)
  367.  
  368. #define        (kStonePerPlayer,                1)
  369. #define        (kStonePerNeutral,            5)
  370.  
  371. #define        (kTreePerPlayer,                1)
  372. #define        (kTreePerNeutral,                0)
  373.  
  374.  
  375. //////////////////////////////////////////////////////////////////////
  376. // forest definitions
  377. #define        (kForestFreeRadius,                8.0)
  378. #define        (kForestsPerPlayer,                1)
  379. #define        (kForestChaosLevel,                .01)
  380. #define        (kMaxClumpsPerForest,                  3)
  381.  
  382. #elif Is5Players
  383. //////////////////////////////////////////////////////////////////////
  384. // 5 PLAYERS...
  385. //////////////////////////////////////////////////////////////////////
  386.  
  387. ResourceSeperation    5 
  388.  
  389. //////////////////////////////////////////////////////////////////////
  390. // terrain definitions
  391. #if        PERCENT(80)
  392.   #define        (kMaxIntElevation,            10)
  393. #else
  394.   #define        (kMaxIntElevation,            16)
  395. #endif
  396.  
  397. #define        (kElevationScale,                Between(1, 1))
  398. #define        (kHeightMapChaos,                Between(35, 45))
  399.                                             
  400. #define        (kMinimumStartPositionToMapEdge    5)
  401. #define        (kOuterPushFromMapCenter        25)
  402. #define        (kInnerPushFromMapCenter         0)    
  403.     
  404. #define        (kConvergentSampleSize,            32) 
  405. #define        (kConvergentThreshold,            10)        
  406.                                             
  407. //////////////////////////////////////////////////////////////////////
  408. // player definitions
  409. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  410. #define        (kPlayerInnerRadius,            0.6)
  411. #define        (kPlayerOuterRadius,            0.95)
  412. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  413. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  414. #define        (kPlayerLandChaos,            0.8)
  415. #define        (kPlayerLandClumps,            Between(1, 1))
  416. #define        (kPlayerFlatChaos,            0.8)
  417. #define        (kPlayerFlatClumps,            Between(1, 1))
  418. #define        (kPlayerTreePercentage,            0.07)
  419.  
  420.  
  421. //////////////////////////////////////////////////////////////////////
  422. // inner neutral definitions
  423. #define        (kNeutralInnerRadius,            0.2)
  424. #define        (kNeutralOuterRadius,            0.5)
  425. #define        (kNeutralOptimalFactor,            0.7)
  426. #define        (kNumInnerNeutrals,                 Between(18, 18))
  427. #define        (kInnerNeutralPercentLand,        0.22)
  428. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  429. #define        (kInnerNeutralTreePercentage,          0.25)
  430. #define        (kInnerNeutralLandChaos,        0.8)
  431. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  432. #define        (kInnerNeutralFlatChaos,        0.8)
  433. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  434.  
  435.  
  436. //////////////////////////////////////////////////////////////////////
  437. // outer neutral definitions
  438. #define        (kNumOuterNeutrals,            Between(39, 39))
  439. #define        (kOuterNeutralPercentLand,        0.65)
  440. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  441. #define        (kOuterNeutralTreePercentage,          0.16)
  442. #define        (kOuterNeutralLandChaos,        0.8)
  443. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  444. #define        (kOuterNeutralFlatChaos,        0.8)
  445. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  446.  
  447. //////////////////////////////////////////////////////////////////////
  448. // resource definitions
  449. #define        (kMaxResourceElevation,            3)
  450. #define        (kResourceToEdgeDistance,        2)
  451. #define        (kResourceToWaterDistance,        4)
  452.  
  453. #define        (kAnimalPerPlayer,            0)
  454. #define        (kAnimalPerNeutral,            0)
  455.  
  456. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  457.   #define  (kBerryPerPlayer,    1) 
  458.   #define  (kBerryPerNeutral,      9)
  459. #else
  460.   #define  (kBerryPerPlayer,    1)
  461.   #define  (kBerryPerNeutral,      0)
  462. #endif 
  463.  
  464.  
  465. #define        (kFishPerPlayer,                0)
  466. #define        (kFishPerNeutral,                0)
  467.  
  468. #define        (kGoldPerPlayer,                1)
  469. #define        (kGoldPerNeutral,                16)
  470.  
  471. #define        (kOilPerPlayer,                0)
  472. #define        (kOilPerNeutral,                0)
  473.  
  474. #define        (kSteelPerPlayer,                1)
  475. #define        (kSteelPerNeutral,            16)
  476.  
  477. #define        (kStonePerPlayer,                1)
  478. #define        (kStonePerNeutral,            6)
  479.  
  480. #define        (kTreePerPlayer,                1)
  481. #define        (kTreePerNeutral,                0)
  482.  
  483.  
  484. //////////////////////////////////////////////////////////////////////
  485. // forest definitions
  486. #define        (kForestFreeRadius,                8.0)
  487. #define        (kForestsPerPlayer,                1)
  488. #define        (kForestChaosLevel,                .01)
  489. #define        (kMaxClumpsPerForest,                  3)
  490.  
  491.  
  492. #elif Is6Players
  493. //////////////////////////////////////////////////////////////////////
  494. // 6 PLAYERS...
  495. //////////////////////////////////////////////////////////////////////
  496.  
  497. ResourceSeperation    5 
  498.  
  499. //////////////////////////////////////////////////////////////////////
  500. // terrain definitions
  501. #if        PERCENT(80)
  502.   #define        (kMaxIntElevation,            10)
  503. #else
  504.   #define        (kMaxIntElevation,            16)
  505. #endif
  506.  
  507. #define        (kElevationScale,                Between(1, 1))
  508. #define        (kHeightMapChaos,                Between(35, 35))
  509.                                             
  510. #define        (kMinimumStartPositionToMapEdge    5)
  511. #define        (kOuterPushFromMapCenter        25)
  512. #define        (kInnerPushFromMapCenter         0)    
  513.     
  514. #define        (kConvergentSampleSize,            32) 
  515. #define        (kConvergentThreshold,            10)
  516.                                             
  517. //////////////////////////////////////////////////////////////////////
  518. // player definitions
  519. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  520. #define        (kPlayerInnerRadius,            0.6)
  521. #define        (kPlayerOuterRadius,            0.95)
  522. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  523. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  524. #define        (kPlayerLandChaos,            0.8)
  525. #define        (kPlayerLandClumps,            Between(1, 1))
  526. #define        (kPlayerFlatChaos,            0.8)
  527. #define        (kPlayerFlatClumps,            Between(1, 1))
  528. #define        (kPlayerTreePercentage,            0.07)
  529.  
  530.  
  531. //////////////////////////////////////////////////////////////////////
  532. // inner neutral definitions
  533. #define        (kNeutralInnerRadius,            0.2)
  534. #define        (kNeutralOuterRadius,            0.5)
  535. #define        (kNeutralOptimalFactor,            0.7)
  536. #define        (kNumInnerNeutrals,                 Between(18, 18))
  537. #define        (kInnerNeutralPercentLand,        0.21)
  538. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  539. #define        (kInnerNeutralTreePercentage,          0.29)
  540. #define        (kInnerNeutralLandChaos,        0.8)
  541. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  542. #define        (kInnerNeutralFlatChaos,        0.8)
  543. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  544.  
  545. //////////////////////////////////////////////////////////////////////
  546. // outer neutral definitions
  547. #define        (kNumOuterNeutrals,            Between(36, 36))
  548. #define        (kOuterNeutralPercentLand,        0.64)
  549. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  550. #define        (kOuterNeutralTreePercentage,          0.19)
  551. #define        (kOuterNeutralLandChaos,        0.8)
  552. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  553. #define        (kOuterNeutralFlatChaos,        0.8)
  554. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  555.  
  556. //////////////////////////////////////////////////////////////////////
  557. // resource definitions
  558. #define        (kMaxResourceElevation,            3)
  559. #define        (kResourceToEdgeDistance,        2)
  560. #define        (kResourceToWaterDistance,        4)
  561.  
  562. #define        (kAnimalPerPlayer,            0)
  563. #define        (kAnimalPerNeutral,            0)
  564.  
  565. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  566.   #define  (kBerryPerPlayer,    2)
  567. #else
  568.   #define  (kBerryPerPlayer,    1)
  569. #endif 
  570.  
  571. #define        (kBerryPerNeutral,            0)
  572.  
  573. #define        (kFishPerPlayer,                0)
  574. #define        (kFishPerNeutral,                0)
  575.  
  576. #define        (kGoldPerPlayer,                1)
  577. #define        (kGoldPerNeutral,                16)
  578.  
  579. #define        (kOilPerPlayer,                0)
  580. #define        (kOilPerNeutral,                0)
  581.  
  582. #define        (kSteelPerPlayer,                1)
  583. #define        (kSteelPerNeutral,            16)
  584.  
  585. #define        (kStonePerPlayer,                1)
  586. #define        (kStonePerNeutral,            6)
  587.  
  588. #define        (kTreePerPlayer,                1)
  589. #define        (kTreePerNeutral,                0)
  590.  
  591.  
  592. //////////////////////////////////////////////////////////////////////
  593. // forest definitions
  594. #define        (kForestFreeRadius,                8.0)
  595. #define        (kForestsPerPlayer,                1 )
  596. #define        (kForestChaosLevel,                .01)
  597. #define        (kMaxClumpsPerForest,                  3)
  598.  
  599.  
  600. #elif Is7Players
  601. //////////////////////////////////////////////////////////////////////
  602. // 7 PLAYERS...
  603. //////////////////////////////////////////////////////////////////////
  604.  
  605. ResourceSeperation    5 
  606.  
  607. //////////////////////////////////////////////////////////////////////
  608. // terrain definitions
  609. #if        PERCENT(80)
  610.   #define        (kMaxIntElevation,            10)
  611. #else
  612.   #define        (kMaxIntElevation,            16)
  613. #endif
  614.  
  615. #define        (kElevationScale,                Between(1, 1))
  616. #define        (kHeightMapChaos,                Between(30, 30))
  617.                                             
  618. #define        (kMinimumStartPositionToMapEdge    5)
  619. #define        (kOuterPushFromMapCenter        25)
  620. #define        (kInnerPushFromMapCenter         0)    
  621.     
  622. #define        (kConvergentSampleSize,            32) 
  623. #define        (kConvergentThreshold,            10)
  624.                                             
  625. //////////////////////////////////////////////////////////////////////
  626. // player definitions
  627. #define        (kMaxAngleBetweenTeamMembers,          30.0)
  628. #define        (kPlayerInnerRadius,            0.6)
  629. #define        (kPlayerOuterRadius,            0.95)
  630. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  631. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  632. #define        (kPlayerLandChaos,            0.8)
  633. #define        (kPlayerLandClumps,            Between(1, 1))
  634. #define        (kPlayerFlatChaos,            0.8)
  635. #define        (kPlayerFlatClumps,            Between(1, 1))
  636. #define        (kPlayerTreePercentage,            0.07)
  637.  
  638.  
  639. //////////////////////////////////////////////////////////////////////
  640. // inner neutral definitions
  641. #define        (kNeutralInnerRadius,            0.2)
  642. #define        (kNeutralOuterRadius,            0.5)
  643. #define        (kNeutralOptimalFactor,            0.7)
  644. #define        (kNumInnerNeutrals,                 Between(18, 18))
  645. #define        (kInnerNeutralPercentLand,        0.2)
  646. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  647. #define        (kInnerNeutralTreePercentage,          0.29)
  648. #define        (kInnerNeutralLandChaos,        0.8)
  649. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  650. #define        (kInnerNeutralFlatChaos,        0.8)
  651. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  652.  
  653. //////////////////////////////////////////////////////////////////////
  654. // outer neutral definitions
  655. #define        (kNumOuterNeutrals,            Between(34, 34))
  656. #define        (kOuterNeutralPercentLand,        0.62)
  657. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  658. #define        (kOuterNeutralTreePercentage,          0.19)
  659. #define        (kOuterNeutralLandChaos,        0.8)
  660. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  661. #define        (kOuterNeutralFlatChaos,        0.8)
  662. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  663.  
  664. //////////////////////////////////////////////////////////////////////
  665. // resource definitions
  666. #define        (kMaxResourceElevation,            3)
  667. #define        (kResourceToEdgeDistance,        2)
  668. #define        (kResourceToWaterDistance,        4)
  669.  
  670. #define        (kAnimalPerPlayer,            0)
  671. #define        (kAnimalPerNeutral,            0)
  672.  
  673. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  674.   #define  (kBerryPerPlayer,    2)
  675. #else
  676.   #define  (kBerryPerPlayer,    1)
  677. #endif 
  678.  
  679. #define        (kBerryPerNeutral,            0)
  680.  
  681. #define        (kFishPerPlayer,                0)
  682. #define        (kFishPerNeutral,                0)
  683.  
  684. #define        (kGoldPerPlayer,                1)
  685. #define        (kGoldPerNeutral,                18)
  686.  
  687. #define        (kOilPerPlayer,                0)
  688. #define        (kOilPerNeutral,                0)
  689.  
  690. #define        (kSteelPerPlayer,                1)
  691. #define        (kSteelPerNeutral,            18)
  692.  
  693. #define        (kStonePerPlayer,                1)
  694. #define        (kStonePerNeutral,            7)
  695.  
  696. #define        (kTreePerPlayer,                1)
  697. #define        (kTreePerNeutral,                0)
  698.  
  699.  
  700. //////////////////////////////////////////////////////////////////////
  701. // forest definitions
  702. #define        (kForestFreeRadius,                8.0)
  703. #define        (kForestsPerPlayer,                1)
  704. #define        (kForestChaosLevel,                .01)
  705. #define        (kMaxClumpsPerForest,                  3)
  706.  
  707. #elif Is8Players
  708. //////////////////////////////////////////////////////////////////////
  709. // 8 PLAYERS...
  710. //////////////////////////////////////////////////////////////////////
  711.  
  712. ResourceSeperation    5 
  713.  
  714. //////////////////////////////////////////////////////////////////////
  715. // terrain definitions
  716. #if        PERCENT(80)
  717.   #define        (kMaxIntElevation,            10)
  718. #else
  719.   #define        (kMaxIntElevation,            16)
  720. #endif
  721.  
  722. #define        (kElevationScale,                Between(1, 1))
  723. #define        (kHeightMapChaos,                Between(30, 30))
  724.                                             
  725. #define        (kMinimumStartPositionToMapEdge    5)
  726. #define        (kOuterPushFromMapCenter        25)
  727. #define        (kInnerPushFromMapCenter         0)    
  728.     
  729. #define        (kConvergentSampleSize,            32) 
  730. #define        (kConvergentThreshold,            10)
  731.                                             
  732. //////////////////////////////////////////////////////////////////////
  733. // player definitions
  734. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  735. #define        (kPlayerInnerRadius,            0.6)
  736. #define        (kPlayerOuterRadius,            0.95)
  737. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  738. #define        (kPlayerPercentFlat,            Between(.99, .99))
  739. #define        (kPlayerLandChaos,            0.8)
  740. #define        (kPlayerLandClumps,            Between(1, 1))
  741. #define        (kPlayerFlatChaos,            0.8)
  742. #define        (kPlayerFlatClumps,            Between(1, 1))
  743. #define        (kPlayerTreePercentage,            0.07)
  744.  
  745. //////////////////////////////////////////////////////////////////////
  746. // inner neutral definitions
  747. #define        (kNeutralInnerRadius,            0.2)
  748. #define        (kNeutralOuterRadius,            0.5)
  749. #define        (kNeutralOptimalFactor,            0.7)
  750. #define        (kNumInnerNeutrals,                 Between(18, 18))
  751. #define        (kInnerNeutralPercentLand,        0.19)
  752. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  753. #define        (kInnerNeutralTreePercentage,          0.25)
  754. #define        (kInnerNeutralLandChaos,        0.8)
  755. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  756. #define        (kInnerNeutralFlatChaos,        0.8)
  757. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  758.  
  759. //////////////////////////////////////////////////////////////////////
  760. // outer neutral definitions
  761. #define        (kNumOuterNeutrals,            Between(32, 32))
  762. #define        (kOuterNeutralPercentLand,        0.61)
  763. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  764. #define        (kOuterNeutralTreePercentage,          0.15)
  765. #define        (kOuterNeutralLandChaos,        0.8)
  766. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  767. #define        (kOuterNeutralFlatChaos,        0.8)
  768. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  769.  
  770. //////////////////////////////////////////////////////////////////////
  771. // resource definitions
  772. #define        (kMaxResourceElevation,            3)
  773. #define        (kResourceToEdgeDistance,        2)
  774. #define        (kResourceToWaterDistance,        4)
  775.  
  776. #define        (kAnimalPerPlayer,            0)
  777. #define        (kAnimalPerNeutral,            0)
  778.  
  779. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  780.   #define  (kBerryPerPlayer,    2)
  781. #else
  782.   #define  (kBerryPerPlayer,    1)
  783. #endif 
  784.  
  785. #define        (kBerryPerNeutral,            0)
  786.  
  787. #define        (kFishPerPlayer,                0)
  788. #define        (kFishPerNeutral,                0)
  789.  
  790. #define        (kGoldPerPlayer,                1)
  791. #define        (kGoldPerNeutral,                21)
  792.  
  793. #define        (kOilPerPlayer,                0)
  794. #define        (kOilPerNeutral,                0)
  795.  
  796. #define        (kSteelPerPlayer,                1)
  797. #define        (kSteelPerNeutral,            21)
  798.  
  799. #define        (kStonePerPlayer,                1)
  800. #define        (kStonePerNeutral,            7)
  801.  
  802. #define        (kTreePerPlayer,                1)
  803. #define        (kTreePerNeutral,                0)
  804.  
  805.  
  806. //////////////////////////////////////////////////////////////////////
  807. // forest definitions
  808. #define        (kForestFreeRadius,                10.0)
  809. #define        (kForestsPerPlayer,                1 )
  810. #define        (kForestChaosLevel,                .01)
  811. #define        (kMaxClumpsPerForest,                  3)
  812.  
  813. #elif Is9Players
  814. //////////////////////////////////////////////////////////////////////
  815. // 9 PLAYERS...
  816. //////////////////////////////////////////////////////////////////////
  817.  
  818. //////////////////////////////////////////////////////////////////////
  819. // terrain definitions
  820. #if        PERCENT(80)
  821.   #define        (kMaxIntElevation,            10)
  822. #else
  823.   #define        (kMaxIntElevation,            16)
  824. #endif
  825.  
  826. #define        (kElevationScale,                Between(1, 1))
  827. #define        (kHeightMapChaos,                Between(30, 30))
  828.                                             
  829. #define        (kMinimumStartPositionToMapEdge    5)
  830. #define        (kOuterPushFromMapCenter        25)
  831. #define        (kInnerPushFromMapCenter         0)    
  832.     
  833. #define        (kConvergentSampleSize,            5) 
  834. #define        (kConvergentThreshold,            10)
  835.                                             
  836. //////////////////////////////////////////////////////////////////////
  837. // player definitions
  838. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  839. #define        (kPlayerInnerRadius,            0.6)
  840. #define        (kPlayerOuterRadius,            0.95)
  841. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  842. #define        (kPlayerPercentFlat,            Between(.99, .99))
  843. #define        (kPlayerLandChaos,            0.8)
  844. #define        (kPlayerLandClumps,            Between(1, 1))
  845. #define        (kPlayerFlatChaos,            0.8)
  846. #define        (kPlayerFlatClumps,            Between(1, 1))
  847. #define        (kPlayerTreePercentage,            0.07)
  848.  
  849. //////////////////////////////////////////////////////////////////////
  850. // inner neutral definitions
  851. #define        (kNeutralInnerRadius,            0.2)
  852. #define        (kNeutralOuterRadius,            0.5)
  853. #define        (kNeutralOptimalFactor,            0.7)
  854. #define        (kNumInnerNeutrals,                 Between(18, 18))
  855. #define        (kInnerNeutralPercentLand,        0.19)
  856. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  857. #define        (kInnerNeutralTreePercentage,          0.25)
  858. #define        (kInnerNeutralLandChaos,        0.8)
  859. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  860. #define        (kInnerNeutralFlatChaos,        0.8)
  861. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  862.  
  863. //////////////////////////////////////////////////////////////////////
  864. // outer neutral definitions
  865. #define        (kNumOuterNeutrals,            Between(32, 32))
  866. #define        (kOuterNeutralPercentLand,        0.56)
  867. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  868. #define        (kOuterNeutralTreePercentage,          0.15)
  869. #define        (kOuterNeutralLandChaos,        0.8)
  870. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  871. #define        (kOuterNeutralFlatChaos,        0.8)
  872. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  873.  
  874. //////////////////////////////////////////////////////////////////////
  875. // resource definitions
  876. #define        (kMaxResourceElevation,            3)
  877. #define        (kResourceToEdgeDistance,        2)
  878. #define        (kResourceToWaterDistance,        4)
  879.  
  880. #define        (kAnimalPerPlayer,            0)
  881. #define        (kAnimalPerNeutral,            0)
  882.  
  883. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  884.   #define  (kBerryPerPlayer,    2)
  885. #else
  886.   #define  (kBerryPerPlayer,    1)
  887. #endif 
  888.  
  889. #define        (kBerryPerNeutral,            0)
  890.  
  891. #define        (kFishPerPlayer,                0)
  892. #define        (kFishPerNeutral,                0)
  893.  
  894. #define        (kGoldPerPlayer,                1)
  895. #define        (kGoldPerNeutral,                24)
  896.  
  897. #define        (kOilPerPlayer,                0)
  898. #define        (kOilPerNeutral,                0)
  899.  
  900. #define        (kSteelPerPlayer,                1)
  901. #define        (kSteelPerNeutral,            24)
  902.  
  903. #define        (kStonePerPlayer,                1)
  904. #define        (kStonePerNeutral,            7)
  905.  
  906. #define        (kTreePerPlayer,                1)
  907. #define        (kTreePerNeutral,                0)
  908.  
  909.  
  910. //////////////////////////////////////////////////////////////////////
  911. // forest definitions
  912. #define        (kForestFreeRadius,                10.0)
  913. #define        (kForestsPerPlayer,                1 )
  914. #define        (kForestChaosLevel,                .01)
  915. #define        (kMaxClumpsPerForest,                  3)
  916.  
  917.  
  918.  
  919. #elif Is10Players
  920. //////////////////////////////////////////////////////////////////////
  921. // 10 PLAYERS...
  922. //////////////////////////////////////////////////////////////////////
  923.  
  924. //////////////////////////////////////////////////////////////////////
  925. // terrain definitions
  926. #if        PERCENT(80)
  927.   #define        (kMaxIntElevation,            10)
  928. #else
  929.   #define        (kMaxIntElevation,            16)
  930. #endif
  931.  
  932. #define        (kElevationScale,                Between(1, 1))
  933. #define        (kHeightMapChaos,                Between(30, 30))
  934.                                             
  935. #define        (kMinimumStartPositionToMapEdge    5)
  936. #define        (kOuterPushFromMapCenter        25)
  937. #define        (kInnerPushFromMapCenter         0)    
  938.     
  939. #define        (kConvergentSampleSize,            5) 
  940. #define        (kConvergentThreshold,            10)
  941.                                             
  942. //////////////////////////////////////////////////////////////////////
  943. // player definitions
  944. #define        (kMaxAngleBetweenTeamMembers,        40.0)
  945. #define        (kPlayerInnerRadius,            0.6)
  946. #define        (kPlayerOuterRadius,            0.95)
  947. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  948. #define        (kPlayerPercentFlat,            Between(.99, .99))
  949. #define        (kPlayerLandChaos,            0.8)
  950. #define        (kPlayerLandClumps,            Between(1, 1))
  951. #define        (kPlayerFlatChaos,            0.8)
  952. #define        (kPlayerFlatClumps,            Between(1, 1))
  953. #define        (kPlayerTreePercentage,            0.07)
  954.  
  955. //////////////////////////////////////////////////////////////////////
  956. // inner neutral definitions
  957. #define        (kNeutralInnerRadius,            0.2)
  958. #define        (kNeutralOuterRadius,            0.5)
  959. #define        (kNeutralOptimalFactor,            0.7)
  960. #define        (kNumInnerNeutrals,                 Between(18, 18))
  961. #define        (kInnerNeutralPercentLand,        0.19)
  962. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  963. #define        (kInnerNeutralTreePercentage,          0.25)
  964. #define        (kInnerNeutralLandChaos,        0.8)
  965. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  966. #define        (kInnerNeutralFlatChaos,        0.8)
  967. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  968.  
  969. //////////////////////////////////////////////////////////////////////
  970. // outer neutral definitions
  971. #define        (kNumOuterNeutrals,            Between(32, 32))
  972. #define        (kOuterNeutralPercentLand,        0.5)
  973. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  974. #define        (kOuterNeutralTreePercentage,          0.15)
  975. #define        (kOuterNeutralLandChaos,        0.8)
  976. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  977. #define        (kOuterNeutralFlatChaos,        0.8)
  978. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  979.  
  980. //////////////////////////////////////////////////////////////////////
  981. // resource definitions
  982. #define        (kMaxResourceElevation,            3)
  983. #define        (kResourceToEdgeDistance,        2)
  984. #define        (kResourceToWaterDistance,        4)
  985.  
  986. #define        (kAnimalPerPlayer,            0)
  987. #define        (kAnimalPerNeutral,            0)
  988.  
  989. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  990.   #define  (kBerryPerPlayer,    2)
  991. #else
  992.   #define  (kBerryPerPlayer,    1)
  993. #endif 
  994.  
  995. #define        (kBerryPerNeutral,            0)
  996.  
  997. #define        (kFishPerPlayer,                0)
  998. #define        (kFishPerNeutral,                0)
  999.  
  1000. #define        (kGoldPerPlayer,                1)
  1001. #define        (kGoldPerNeutral,                13)
  1002.  
  1003. #define        (kOilPerPlayer,                0)
  1004. #define        (kOilPerNeutral,                0)
  1005.  
  1006. #define        (kSteelPerPlayer,                1)
  1007. #define        (kSteelPerNeutral,            13)
  1008.  
  1009. #define        (kStonePerPlayer,                1)
  1010. #define        (kStonePerNeutral,            7)
  1011.  
  1012. #define        (kTreePerPlayer,                1)
  1013. #define        (kTreePerNeutral,                0)
  1014.  
  1015.  
  1016. //////////////////////////////////////////////////////////////////////
  1017. // forest definitions
  1018. #define        (kForestFreeRadius,                10.0)
  1019. #define        (kForestsPerPlayer,                1 )
  1020. #define        (kForestChaosLevel,                .01)
  1021. #define        (kMaxClumpsPerForest,                  3)
  1022.  
  1023.  
  1024.  
  1025. #elif Is11Players
  1026. //////////////////////////////////////////////////////////////////////
  1027. // 11 PLAYERS...
  1028. //////////////////////////////////////////////////////////////////////
  1029.  
  1030. //////////////////////////////////////////////////////////////////////
  1031. // terrain definitions
  1032. #define        (kMaxIntElevation,            15)
  1033. #define        (kElevationScale,                Between(1, 1))
  1034. #define        (kHeightMapChaos,                Between(30, 60))
  1035.  
  1036. #define        (kMinimumStartPositionToMapEdge    2)
  1037. #define        (kOuterPushFromMapCenter        31)
  1038. #define        (kInnerPushFromMapCenter         0)    
  1039.                                             
  1040. //////////////////////////////////////////////////////////////////////
  1041. // player definitions
  1042. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1043. #define        (kPlayerInnerRadius,            0.6)
  1044. #define        (kPlayerOuterRadius,            0.95)
  1045. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1046. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1047. #define        (kPlayerLandChaos,            0.8)
  1048. #define        (kPlayerLandClumps,            Between(2, 2))
  1049. #define        (kPlayerFlatChaos,            0.8)
  1050. #define        (kPlayerFlatClumps,            Between(1, 2))
  1051. #define        (kPlayerTreePercentage,            0.08)
  1052.  
  1053. //////////////////////////////////////////////////////////////////////
  1054. // inner neutral definitions
  1055. #define        (kNeutralInnerRadius,            0.2)
  1056. #define        (kNeutralOuterRadius,            0.5)
  1057. #define        (kNeutralOptimalFactor,            0.7)
  1058. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1059. #define        (kInnerNeutralPercentLand,        0.19)
  1060. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1061. #define        (kInnerNeutralTreePercentage,          0.2)
  1062. #define        (kInnerNeutralLandChaos,        0.8)
  1063. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1064. #define        (kInnerNeutralFlatChaos,        0.8)
  1065. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1066.  
  1067. //////////////////////////////////////////////////////////////////////
  1068. // outer neutral definitions
  1069. #define        (kNumOuterNeutrals,            Between(32, 32))
  1070. #define        (kOuterNeutralPercentLand,        0.61)
  1071. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1072. #define        (kOuterNeutralTreePercentage,          0.15)
  1073. #define        (kOuterNeutralLandChaos,        0.8)
  1074. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1075. #define        (kOuterNeutralFlatChaos,        0.8)
  1076. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1077.  
  1078. //////////////////////////////////////////////////////////////////////
  1079. // resource definitions
  1080. #define        (kMaxResourceElevation,            4)
  1081. #define        (kResourceToEdgeDistance,        2)
  1082. #define        (kResourceToWaterDistance,        4)
  1083.  
  1084. #define        (kAnimalPerPlayer,            0)
  1085. #define        (kAnimalPerNeutral,            0)
  1086.  
  1087. #define        (kBerryPerPlayer,                1)
  1088. #define        (kBerryPerNeutral,            0)
  1089.  
  1090. #define        (kFishPerPlayer,                0)
  1091. #define        (kFishPerNeutral,                0)
  1092.  
  1093. #define        (kGoldPerPlayer,                1)
  1094. #define        (kGoldPerNeutral,                19)
  1095.  
  1096. #define        (kOilPerPlayer,                0)
  1097. #define        (kOilPerNeutral,                0)
  1098.  
  1099. #define        (kSteelPerPlayer,                1)
  1100. #define        (kSteelPerNeutral,            19)
  1101.  
  1102. #define        (kStonePerPlayer,                1)
  1103. #define        (kStonePerNeutral,            7)
  1104.  
  1105. #define        (kTreePerPlayer,                0)
  1106. #define        (kTreePerNeutral,                0)
  1107.  
  1108.  
  1109. //////////////////////////////////////////////////////////////////////
  1110. // forest definitions
  1111. #define        (kForestFreeRadius,                10.0)
  1112. #define        (kForestsPerPlayer,                1 )
  1113. #define        (kForestChaosLevel,                0.5)
  1114. #define        (kMaxClumpsPerForest,                  2)
  1115.  
  1116.  
  1117. #elif Is12Players
  1118. //////////////////////////////////////////////////////////////////////
  1119. // 12 PLAYERS...
  1120. //////////////////////////////////////////////////////////////////////
  1121.  
  1122. //////////////////////////////////////////////////////////////////////
  1123. // terrain definitions
  1124. #define        (kMaxIntElevation,            15)
  1125. #define        (kElevationScale,                Between(1, 1))
  1126. #define        (kHeightMapChaos,                Between(30, 60))
  1127.  
  1128. #define        (kMinimumStartPositionToMapEdge    2)
  1129. #define        (kOuterPushFromMapCenter        31)
  1130. #define        (kInnerPushFromMapCenter         0)    
  1131.                                             
  1132. //////////////////////////////////////////////////////////////////////
  1133. // player definitions
  1134. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1135. #define        (kPlayerInnerRadius,            0.6)
  1136. #define        (kPlayerOuterRadius,            0.95)
  1137. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1138. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1139. #define        (kPlayerLandChaos,            0.8)
  1140. #define        (kPlayerLandClumps,            Between(2, 2))
  1141. #define        (kPlayerFlatChaos,            0.8)
  1142. #define        (kPlayerFlatClumps,            Between(1, 2))
  1143. #define        (kPlayerTreePercentage,            0.08)
  1144.  
  1145. //////////////////////////////////////////////////////////////////////
  1146. // inner neutral definitions
  1147. #define        (kNeutralInnerRadius,            0.2)
  1148. #define        (kNeutralOuterRadius,            0.5)
  1149. #define        (kNeutralOptimalFactor,            0.7)
  1150. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1151. #define        (kInnerNeutralPercentLand,        0.19)
  1152. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1153. #define        (kInnerNeutralTreePercentage,          0.2)
  1154. #define        (kInnerNeutralLandChaos,        0.8)
  1155. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1156. #define        (kInnerNeutralFlatChaos,        0.8)
  1157. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1158.  
  1159. //////////////////////////////////////////////////////////////////////
  1160. // outer neutral definitions
  1161. #define        (kNumOuterNeutrals,            Between(32, 32))
  1162. #define        (kOuterNeutralPercentLand,        0.61)
  1163. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1164. #define        (kOuterNeutralTreePercentage,          0.15)
  1165. #define        (kOuterNeutralLandChaos,        0.8)
  1166. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1167. #define        (kOuterNeutralFlatChaos,        0.8)
  1168. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1169.  
  1170. //////////////////////////////////////////////////////////////////////
  1171. // resource definitions
  1172. #define        (kMaxResourceElevation,            4)
  1173. #define        (kResourceToEdgeDistance,        2)
  1174. #define        (kResourceToWaterDistance,        4)
  1175.  
  1176. #define        (kAnimalPerPlayer,            0)
  1177. #define        (kAnimalPerNeutral,            0)
  1178.  
  1179. #define        (kBerryPerPlayer,                1)
  1180. #define        (kBerryPerNeutral,            0)
  1181.  
  1182. #define        (kFishPerPlayer,                0)
  1183. #define        (kFishPerNeutral,                0)
  1184.  
  1185. #define        (kGoldPerPlayer,                1)
  1186. #define        (kGoldPerNeutral,                19)
  1187.  
  1188. #define        (kOilPerPlayer,                0)
  1189. #define        (kOilPerNeutral,                0)
  1190.  
  1191. #define        (kSteelPerPlayer,                1)
  1192. #define        (kSteelPerNeutral,            19)
  1193.  
  1194. #define        (kStonePerPlayer,                1)
  1195. #define        (kStonePerNeutral,            7)
  1196.  
  1197. #define        (kTreePerPlayer,                0)
  1198. #define        (kTreePerNeutral,                0)
  1199.  
  1200.  
  1201. //////////////////////////////////////////////////////////////////////
  1202. // forest definitions
  1203. #define        (kForestFreeRadius,                10.0)
  1204. #define        (kForestsPerPlayer,                1 )
  1205. #define        (kForestChaosLevel,                0.5)
  1206. #define        (kMaxClumpsPerForest,                  2)
  1207.  
  1208.  
  1209. #elif Is13Players
  1210. //////////////////////////////////////////////////////////////////////
  1211. // 13 PLAYERS...
  1212. //////////////////////////////////////////////////////////////////////
  1213.  
  1214. //////////////////////////////////////////////////////////////////////
  1215. // terrain definitions
  1216. #define        (kMaxIntElevation,            15)
  1217. #define        (kElevationScale,                Between(1, 1))
  1218. #define        (kHeightMapChaos,                Between(30, 60))
  1219.  
  1220. #define        (kMinimumStartPositionToMapEdge    2)
  1221. #define        (kOuterPushFromMapCenter        31)
  1222. #define        (kInnerPushFromMapCenter         0)    
  1223.                                             
  1224. //////////////////////////////////////////////////////////////////////
  1225. // player definitions
  1226. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1227. #define        (kPlayerInnerRadius,            0.6)
  1228. #define        (kPlayerOuterRadius,            0.95)
  1229. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1230. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1231. #define        (kPlayerLandChaos,            0.8)
  1232. #define        (kPlayerLandClumps,            Between(2, 2))
  1233. #define        (kPlayerFlatChaos,            0.8)
  1234. #define        (kPlayerFlatClumps,            Between(1, 2))
  1235. #define        (kPlayerTreePercentage,            0.08)
  1236.  
  1237. //////////////////////////////////////////////////////////////////////
  1238. // inner neutral definitions
  1239. #define        (kNeutralInnerRadius,            0.2)
  1240. #define        (kNeutralOuterRadius,            0.5)
  1241. #define        (kNeutralOptimalFactor,            0.7)
  1242. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1243. #define        (kInnerNeutralPercentLand,        0.19)
  1244. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1245. #define        (kInnerNeutralTreePercentage,          0.2)
  1246. #define        (kInnerNeutralLandChaos,        0.8)
  1247. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1248. #define        (kInnerNeutralFlatChaos,        0.8)
  1249. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1250.  
  1251. //////////////////////////////////////////////////////////////////////
  1252. // outer neutral definitions
  1253. #define        (kNumOuterNeutrals,            Between(32, 32))
  1254. #define        (kOuterNeutralPercentLand,        0.61)
  1255. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1256. #define        (kOuterNeutralTreePercentage,          0.15)
  1257. #define        (kOuterNeutralLandChaos,        0.8)
  1258. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1259. #define        (kOuterNeutralFlatChaos,        0.8)
  1260. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1261.  
  1262. //////////////////////////////////////////////////////////////////////
  1263. // resource definitions
  1264. #define        (kMaxResourceElevation,            4)
  1265. #define        (kResourceToEdgeDistance,        2)
  1266. #define        (kResourceToWaterDistance,        4)
  1267.  
  1268. #define        (kAnimalPerPlayer,            0)
  1269. #define        (kAnimalPerNeutral,            0)
  1270.  
  1271. #define        (kBerryPerPlayer,                1)
  1272. #define        (kBerryPerNeutral,            0)
  1273.  
  1274. #define        (kFishPerPlayer,                0)
  1275. #define        (kFishPerNeutral,                0)
  1276.  
  1277. #define        (kGoldPerPlayer,                1)
  1278. #define        (kGoldPerNeutral,                19)
  1279.  
  1280. #define        (kOilPerPlayer,                0)
  1281. #define        (kOilPerNeutral,                0)
  1282.  
  1283. #define        (kSteelPerPlayer,                1)
  1284. #define        (kSteelPerNeutral,            19)
  1285.  
  1286. #define        (kStonePerPlayer,                1)
  1287. #define        (kStonePerNeutral,            7)
  1288.  
  1289. #define        (kTreePerPlayer,                0)
  1290. #define        (kTreePerNeutral,                0)
  1291.  
  1292.  
  1293. //////////////////////////////////////////////////////////////////////
  1294. // forest definitions
  1295. #define        (kForestFreeRadius,                10.0)
  1296. #define        (kForestsPerPlayer,                1 )
  1297. #define        (kForestChaosLevel,                0.5)
  1298. #define        (kMaxClumpsPerForest,                  2)
  1299.  
  1300.  
  1301. #elif Is14Players
  1302. //////////////////////////////////////////////////////////////////////
  1303. // 14 PLAYERS...
  1304. //////////////////////////////////////////////////////////////////////
  1305.  
  1306. //////////////////////////////////////////////////////////////////////
  1307. // terrain definitions
  1308. #define        (kMaxIntElevation,            15)
  1309. #define        (kElevationScale,                Between(1, 1))
  1310. #define        (kHeightMapChaos,                Between(30, 60))
  1311.  
  1312. #define        (kMinimumStartPositionToMapEdge    2)
  1313. #define        (kOuterPushFromMapCenter        31)
  1314. #define        (kInnerPushFromMapCenter         0)    
  1315.                                             
  1316. //////////////////////////////////////////////////////////////////////
  1317. // player definitions
  1318. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1319. #define        (kPlayerInnerRadius,            0.6)
  1320. #define        (kPlayerOuterRadius,            0.95)
  1321. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1322. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1323. #define        (kPlayerLandChaos,            0.8)
  1324. #define        (kPlayerLandClumps,            Between(2, 2))
  1325. #define        (kPlayerFlatChaos,            0.8)
  1326. #define        (kPlayerFlatClumps,            Between(1, 2))
  1327. #define        (kPlayerTreePercentage,            0.08)
  1328.  
  1329. //////////////////////////////////////////////////////////////////////
  1330. // inner neutral definitions
  1331. #define        (kNeutralInnerRadius,            0.2)
  1332. #define        (kNeutralOuterRadius,            0.5)
  1333. #define        (kNeutralOptimalFactor,            0.7)
  1334. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1335. #define        (kInnerNeutralPercentLand,        0.19)
  1336. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1337. #define        (kInnerNeutralTreePercentage,          0.2)
  1338. #define        (kInnerNeutralLandChaos,        0.8)
  1339. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1340. #define        (kInnerNeutralFlatChaos,        0.8)
  1341. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1342.  
  1343. //////////////////////////////////////////////////////////////////////
  1344. // outer neutral definitions
  1345. #define        (kNumOuterNeutrals,            Between(32, 32))
  1346. #define        (kOuterNeutralPercentLand,        0.61)
  1347. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1348. #define        (kOuterNeutralTreePercentage,          0.15)
  1349. #define        (kOuterNeutralLandChaos,        0.8)
  1350. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1351. #define        (kOuterNeutralFlatChaos,        0.8)
  1352. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1353.  
  1354. //////////////////////////////////////////////////////////////////////
  1355. // resource definitions
  1356. #define        (kMaxResourceElevation,            4)
  1357. #define        (kResourceToEdgeDistance,        2)
  1358. #define        (kResourceToWaterDistance,        4)
  1359.  
  1360. #define        (kAnimalPerPlayer,            0)
  1361. #define        (kAnimalPerNeutral,            0)
  1362.  
  1363. #define        (kBerryPerPlayer,                1)
  1364. #define        (kBerryPerNeutral,            0)
  1365.  
  1366. #define        (kFishPerPlayer,                0)
  1367. #define        (kFishPerNeutral,                0)
  1368.  
  1369. #define        (kGoldPerPlayer,                1)
  1370. #define        (kGoldPerNeutral,                19)
  1371.  
  1372. #define        (kOilPerPlayer,                0)
  1373. #define        (kOilPerNeutral,                0)
  1374.  
  1375. #define        (kSteelPerPlayer,                1)
  1376. #define        (kSteelPerNeutral,            19)
  1377.  
  1378. #define        (kStonePerPlayer,                1)
  1379. #define        (kStonePerNeutral,            7)
  1380.  
  1381. #define        (kTreePerPlayer,                0)
  1382. #define        (kTreePerNeutral,                0)
  1383.  
  1384.  
  1385. //////////////////////////////////////////////////////////////////////
  1386. // forest definitions
  1387. #define        (kForestFreeRadius,                10.0)
  1388. #define        (kForestsPerPlayer,                1 )
  1389. #define        (kForestChaosLevel,                0.5)
  1390. #define        (kMaxClumpsPerForest,                  2)
  1391.  
  1392.  
  1393. #elif Is15Players
  1394. //////////////////////////////////////////////////////////////////////
  1395. // 15 PLAYERS...
  1396. //////////////////////////////////////////////////////////////////////
  1397.  
  1398. //////////////////////////////////////////////////////////////////////
  1399. // terrain definitions
  1400. #define        (kMaxIntElevation,            15)
  1401. #define        (kElevationScale,                Between(1, 1))
  1402. #define        (kHeightMapChaos,                Between(30, 60))
  1403.  
  1404. #define        (kMinimumStartPositionToMapEdge    2)
  1405. #define        (kOuterPushFromMapCenter        31)
  1406. #define        (kInnerPushFromMapCenter         0)    
  1407.                                             
  1408. //////////////////////////////////////////////////////////////////////
  1409. // player definitions
  1410. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1411. #define        (kPlayerInnerRadius,            0.6)
  1412. #define        (kPlayerOuterRadius,            0.95)
  1413. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1414. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1415. #define        (kPlayerLandChaos,            0.8)
  1416. #define        (kPlayerLandClumps,            Between(2, 2))
  1417. #define        (kPlayerFlatChaos,            0.8)
  1418. #define        (kPlayerFlatClumps,            Between(1, 2))
  1419. #define        (kPlayerTreePercentage,            0.08)
  1420.  
  1421. //////////////////////////////////////////////////////////////////////
  1422. // inner neutral definitions
  1423. #define        (kNeutralInnerRadius,            0.2)
  1424. #define        (kNeutralOuterRadius,            0.5)
  1425. #define        (kNeutralOptimalFactor,            0.7)
  1426. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1427. #define        (kInnerNeutralPercentLand,        0.19)
  1428. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1429. #define        (kInnerNeutralTreePercentage,          0.2)
  1430. #define        (kInnerNeutralLandChaos,        0.8)
  1431. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1432. #define        (kInnerNeutralFlatChaos,        0.8)
  1433. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1434.  
  1435. //////////////////////////////////////////////////////////////////////
  1436. // outer neutral definitions
  1437. #define        (kNumOuterNeutrals,            Between(32, 32))
  1438. #define        (kOuterNeutralPercentLand,        0.61)
  1439. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1440. #define        (kOuterNeutralTreePercentage,          0.15)
  1441. #define        (kOuterNeutralLandChaos,        0.8)
  1442. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1443. #define        (kOuterNeutralFlatChaos,        0.8)
  1444. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1445.  
  1446. //////////////////////////////////////////////////////////////////////
  1447. // resource definitions
  1448. #define        (kMaxResourceElevation,            4)
  1449. #define        (kResourceToEdgeDistance,        2)
  1450. #define        (kResourceToWaterDistance,        4)
  1451.  
  1452. #define        (kAnimalPerPlayer,            0)
  1453. #define        (kAnimalPerNeutral,            0)
  1454.  
  1455. #define        (kBerryPerPlayer,                1)
  1456. #define        (kBerryPerNeutral,            0)
  1457.  
  1458. #define        (kFishPerPlayer,                0)
  1459. #define        (kFishPerNeutral,                0)
  1460.  
  1461. #define        (kGoldPerPlayer,                1)
  1462. #define        (kGoldPerNeutral,                19)
  1463.  
  1464. #define        (kOilPerPlayer,                0)
  1465. #define        (kOilPerNeutral,                0)
  1466.  
  1467. #define        (kSteelPerPlayer,                1)
  1468. #define        (kSteelPerNeutral,            19)
  1469.  
  1470. #define        (kStonePerPlayer,                1)
  1471. #define        (kStonePerNeutral,            7)
  1472.  
  1473. #define        (kTreePerPlayer,                0)
  1474. #define        (kTreePerNeutral,                0)
  1475.  
  1476.  
  1477. //////////////////////////////////////////////////////////////////////
  1478. // forest definitions
  1479. #define        (kForestFreeRadius,                10.0)
  1480. #define        (kForestsPerPlayer,                1 )
  1481. #define        (kForestChaosLevel,                0.5)
  1482. #define        (kMaxClumpsPerForest,                  2)
  1483.  
  1484.  
  1485. #elif Is16Players
  1486. //////////////////////////////////////////////////////////////////////
  1487. // 16 PLAYERS...
  1488. //////////////////////////////////////////////////////////////////////
  1489.  
  1490. //////////////////////////////////////////////////////////////////////
  1491. // terrain definitions
  1492. #define        (kMaxIntElevation,            15)
  1493. #define        (kElevationScale,                Between(1, 1))
  1494. #define        (kHeightMapChaos,                Between(30, 60))
  1495.  
  1496. #define        (kMinimumStartPositionToMapEdge    2)
  1497. #define        (kOuterPushFromMapCenter        31)
  1498. #define        (kInnerPushFromMapCenter         0)    
  1499.                                             
  1500. //////////////////////////////////////////////////////////////////////
  1501. // player definitions
  1502. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1503. #define        (kPlayerInnerRadius,            0.6)
  1504. #define        (kPlayerOuterRadius,            0.95)
  1505. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1506. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1507. #define        (kPlayerLandChaos,            0.8)
  1508. #define        (kPlayerLandClumps,            Between(2, 2))
  1509. #define        (kPlayerFlatChaos,            0.8)
  1510. #define        (kPlayerFlatClumps,            Between(1, 2))
  1511. #define        (kPlayerTreePercentage,            0.08)
  1512.  
  1513. //////////////////////////////////////////////////////////////////////
  1514. // inner neutral definitions
  1515. #define        (kNeutralInnerRadius,            0.2)
  1516. #define        (kNeutralOuterRadius,            0.5)
  1517. #define        (kNeutralOptimalFactor,            0.7)
  1518. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1519. #define        (kInnerNeutralPercentLand,        0.19)
  1520. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1521. #define        (kInnerNeutralTreePercentage,          0.2)
  1522. #define        (kInnerNeutralLandChaos,        0.8)
  1523. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1524. #define        (kInnerNeutralFlatChaos,        0.8)
  1525. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1526.  
  1527. //////////////////////////////////////////////////////////////////////
  1528. // outer neutral definitions
  1529. #define        (kNumOuterNeutrals,            Between(32, 32))
  1530. #define        (kOuterNeutralPercentLand,        0.61)
  1531. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1532. #define        (kOuterNeutralTreePercentage,          0.15)
  1533. #define        (kOuterNeutralLandChaos,        0.8)
  1534. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1535. #define        (kOuterNeutralFlatChaos,        0.8)
  1536. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1537.  
  1538. //////////////////////////////////////////////////////////////////////
  1539. // resource definitions
  1540. #define        (kMaxResourceElevation,            4)
  1541. #define        (kResourceToEdgeDistance,        2)
  1542. #define        (kResourceToWaterDistance,        4)
  1543.  
  1544. #define        (kAnimalPerPlayer,            0)
  1545. #define        (kAnimalPerNeutral,            0)
  1546.  
  1547. #define        (kBerryPerPlayer,                1)
  1548. #define        (kBerryPerNeutral,            0)
  1549.  
  1550. #define        (kFishPerPlayer,                0)
  1551. #define        (kFishPerNeutral,                0)
  1552.  
  1553. #define        (kGoldPerPlayer,                1)
  1554. #define        (kGoldPerNeutral,                19)
  1555.  
  1556. #define        (kOilPerPlayer,                0)
  1557. #define        (kOilPerNeutral,                0)
  1558.  
  1559. #define        (kSteelPerPlayer,                1)
  1560. #define        (kSteelPerNeutral,            19)
  1561.  
  1562. #define        (kStonePerPlayer,                1)
  1563. #define        (kStonePerNeutral,            7)
  1564.  
  1565. #define        (kTreePerPlayer,                0)
  1566. #define        (kTreePerNeutral,                0)
  1567.  
  1568.  
  1569. //////////////////////////////////////////////////////////////////////
  1570. // forest definitions
  1571. #define        (kForestFreeRadius,                10.0)
  1572. #define        (kForestsPerPlayer,                1 )
  1573. #define        (kForestChaosLevel,                0.5)
  1574. #define        (kMaxClumpsPerForest,                  2)
  1575.  
  1576.  
  1577. //////////////////////////////////////////////////////////////////////
  1578. // End of if...elif... command
  1579. #endif
  1580.  
  1581. #endif        // NOTDEFINED(HIGHLANDS_HUGE_RMV)
  1582.